home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / symtable.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-29  |  12KB  |  320 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. """Interface to the compiler's internal symbol tables"""
  5. import _symtable
  6. from _symtable import USE, DEF_GLOBAL, DEF_LOCAL, DEF_PARAM, DEF_STAR, DEF_DOUBLESTAR, DEF_INTUPLE, DEF_FREE, DEF_FREE_GLOBAL, DEF_FREE_CLASS, DEF_IMPORT, DEF_BOUND, OPT_IMPORT_STAR, OPT_EXEC, OPT_BARE_EXEC
  7. import weakref
  8. __all__ = [
  9.     'symtable',
  10.     'SymbolTable',
  11.     'newSymbolTable',
  12.     'Class',
  13.     'Function',
  14.     'Symbol']
  15.  
  16. def symtable(code, filename, compile_type):
  17.     raw = _symtable.symtable(code, filename, compile_type)
  18.     for top in raw.itervalues():
  19.         if top.name == 'top':
  20.             break
  21.             continue
  22.     
  23.     return newSymbolTable(top, filename)
  24.  
  25.  
  26. class SymbolTableFactory:
  27.     
  28.     def __init__(self):
  29.         self._SymbolTableFactory__memo = weakref.WeakValueDictionary()
  30.  
  31.     
  32.     def new(self, table, filename):
  33.         if table.type == _symtable.TYPE_FUNCTION:
  34.             return Function(table, filename)
  35.         
  36.         if table.type == _symtable.TYPE_CLASS:
  37.             return Class(table, filename)
  38.         
  39.         return SymbolTable(table, filename)
  40.  
  41.     
  42.     def __call__(self, table, filename):
  43.         key = (table, filename)
  44.         obj = self._SymbolTableFactory__memo.get(key, None)
  45.         if obj is None:
  46.             obj = self._SymbolTableFactory__memo[key] = self.new(table, filename)
  47.         
  48.         return obj
  49.  
  50.  
  51. newSymbolTable = SymbolTableFactory()
  52.  
  53. def is_free(flags):
  54.     if flags & (USE | DEF_FREE) and flags & (DEF_LOCAL | DEF_PARAM | DEF_GLOBAL):
  55.         return True
  56.     
  57.     if flags & DEF_FREE_CLASS:
  58.         return True
  59.     
  60.     return False
  61.  
  62.  
  63. class SymbolTable:
  64.     
  65.     def __init__(self, raw_table, filename):
  66.         self._table = raw_table
  67.         self._filename = filename
  68.         self._symbols = { }
  69.  
  70.     
  71.     def __repr__(self):
  72.         if self.__class__ == SymbolTable:
  73.             kind = ''
  74.         else:
  75.             kind = '%s ' % self.__class__.__name__
  76.         if self._table.name == 'global':
  77.             return '<%sSymbolTable for module %s>' % (kind, self._filename)
  78.         else:
  79.             return '<%sSymbolTable for %s in %s>' % (kind, self._table.name, self._filename)
  80.  
  81.     
  82.     def get_type(self):
  83.         if self._table.type == _symtable.TYPE_MODULE:
  84.             return 'module'
  85.         
  86.         if self._table.type == _symtable.TYPE_FUNCTION:
  87.             return 'function'
  88.         
  89.         if self._table.type == _symtable.TYPE_CLASS:
  90.             return 'class'
  91.         
  92.         if not self._table.type in (1, 2, 3):
  93.             raise AssertionError, 'unexpected type: %s' % self._table.type
  94.  
  95.     
  96.     def get_id(self):
  97.         return self._table.id
  98.  
  99.     
  100.     def get_name(self):
  101.         return self._table.name
  102.  
  103.     
  104.     def get_lineno(self):
  105.         return self._table.lineno
  106.  
  107.     
  108.     def is_optimized(self):
  109.         if self._table.type == _symtable.TYPE_FUNCTION:
  110.             pass
  111.         return bool(not (self._table.optimized))
  112.  
  113.     
  114.     def is_nested(self):
  115.         return bool(self._table.nested)
  116.  
  117.     
  118.     def has_children(self):
  119.         return bool(self._table.children)
  120.  
  121.     
  122.     def has_exec(self):
  123.         '''Return true if the scope uses exec'''
  124.         return bool(self._table.optimized & (OPT_EXEC | OPT_BARE_EXEC))
  125.  
  126.     
  127.     def has_import_star(self):
  128.         '''Return true if the scope uses import *'''
  129.         return bool(self._table.optimized & OPT_IMPORT_STAR)
  130.  
  131.     
  132.     def get_identifiers(self):
  133.         return self._table.symbols.keys()
  134.  
  135.     
  136.     def lookup(self, name):
  137.         sym = self._symbols.get(name)
  138.         if sym is None:
  139.             flags = self._table.symbols[name]
  140.             namespaces = self._SymbolTable__check_children(name)
  141.             sym = self._symbols[name] = Symbol(name, flags, namespaces)
  142.         
  143.         return sym
  144.  
  145.     
  146.     def get_symbols(self):
  147.         return [ self.lookup(ident) for ident in self.get_identifiers() ]
  148.  
  149.     
  150.     def __check_children(self, name):
  151.         return _[1]
  152.  
  153.     
  154.     def get_children(self):
  155.         return [ newSymbolTable(st, self._filename) for st in self._table.children ]
  156.  
  157.  
  158.  
  159. class Function(SymbolTable):
  160.     __params = None
  161.     __locals = None
  162.     __frees = None
  163.     __globals = None
  164.     
  165.     def __idents_matching(self, test_func):
  166.         return [](_[1])
  167.  
  168.     
  169.     def get_parameters(self):
  170.         if self._Function__params is None:
  171.             self._Function__params = self._Function__idents_matching((lambda x: x & DEF_PARAM))
  172.         
  173.         return self._Function__params
  174.  
  175.     
  176.     def get_locals(self):
  177.         if self._Function__locals is None:
  178.             self._Function__locals = self._Function__idents_matching((lambda x: x & DEF_BOUND))
  179.         
  180.         return self._Function__locals
  181.  
  182.     
  183.     def get_globals(self):
  184.         if self._Function__globals is None:
  185.             glob = DEF_GLOBAL | DEF_FREE_GLOBAL
  186.             self._Function__globals = (self._Function__idents_matching,)((lambda x: x & glob))
  187.         
  188.         return self._Function__globals
  189.  
  190.     
  191.     def get_frees(self):
  192.         if self._Function__frees is None:
  193.             self._Function__frees = self._Function__idents_matching(is_free)
  194.         
  195.         return self._Function__frees
  196.  
  197.  
  198.  
  199. class Class(SymbolTable):
  200.     __methods = None
  201.     
  202.     def get_methods(self):
  203.         if self._Class__methods is None:
  204.             d = { }
  205.             for st in self._table.children:
  206.                 d[st.name] = 1
  207.             
  208.             self._Class__methods = tuple(d)
  209.         
  210.         return self._Class__methods
  211.  
  212.  
  213.  
  214. class Symbol:
  215.     
  216.     def __init__(self, name, flags, namespaces = None):
  217.         self._Symbol__name = name
  218.         self._Symbol__flags = flags
  219.         if not namespaces:
  220.             pass
  221.         self._Symbol__namespaces = ()
  222.  
  223.     
  224.     def __repr__(self):
  225.         return "<symbol '%s'>" % self._Symbol__name
  226.  
  227.     
  228.     def get_name(self):
  229.         return self._Symbol__name
  230.  
  231.     
  232.     def is_referenced(self):
  233.         return bool(self._Symbol__flags & _symtable.USE)
  234.  
  235.     
  236.     def is_parameter(self):
  237.         return bool(self._Symbol__flags & DEF_PARAM)
  238.  
  239.     
  240.     def is_global(self):
  241.         if not self._Symbol__flags & DEF_GLOBAL:
  242.             pass
  243.         return bool(self._Symbol__flags & DEF_FREE_GLOBAL)
  244.  
  245.     
  246.     def is_vararg(self):
  247.         return bool(self._Symbol__flags & DEF_STAR)
  248.  
  249.     
  250.     def is_keywordarg(self):
  251.         return bool(self._Symbol__flags & DEF_DOUBLESTAR)
  252.  
  253.     
  254.     def is_local(self):
  255.         return bool(self._Symbol__flags & DEF_BOUND)
  256.  
  257.     
  258.     def is_free(self):
  259.         if self._Symbol__flags & (USE | DEF_FREE) and self._Symbol__flags & (DEF_LOCAL | DEF_PARAM | DEF_GLOBAL):
  260.             return True
  261.         
  262.         if self._Symbol__flags & DEF_FREE_CLASS:
  263.             return True
  264.         
  265.         return False
  266.  
  267.     
  268.     def is_imported(self):
  269.         return bool(self._Symbol__flags & DEF_IMPORT)
  270.  
  271.     
  272.     def is_assigned(self):
  273.         return bool(self._Symbol__flags & DEF_LOCAL)
  274.  
  275.     
  276.     def is_in_tuple(self):
  277.         return bool(self._Symbol__flags & DEF_INTUPLE)
  278.  
  279.     
  280.     def is_namespace(self):
  281.         '''Returns true if name binding introduces new namespace.
  282.  
  283.         If the name is used as the target of a function or class
  284.         statement, this will be true.
  285.  
  286.         Note that a single name can be bound to multiple objects.  If
  287.         is_namespace() is true, the name may also be bound to other
  288.         objects, like an int or list, that does not introduce a new
  289.         namespace.
  290.         '''
  291.         return bool(self._Symbol__namespaces)
  292.  
  293.     
  294.     def get_namespaces(self):
  295.         '''Return a list of namespaces bound to this name'''
  296.         return self._Symbol__namespaces
  297.  
  298.     
  299.     def get_namespace(self):
  300.         '''Returns the single namespace bound to this name.
  301.  
  302.         Raises ValueError if the name is bound to multiple namespaces.
  303.         '''
  304.         if len(self._Symbol__namespaces) != 1:
  305.             raise ValueError, 'name is bound to multiple namespaces'
  306.         
  307.         return self._Symbol__namespaces[0]
  308.  
  309.  
  310. if __name__ == '__main__':
  311.     import os
  312.     import sys
  313.     src = open(sys.argv[0]).read()
  314.     mod = symtable(src, os.path.split(sys.argv[0])[1], 'exec')
  315.     for ident in mod.get_identifiers():
  316.         info = mod.lookup(ident)
  317.         print info, info.is_local(), info.is_namespace()
  318.     
  319.  
  320.